const userApi = require('../../../api/user')
const authUtils = require('../../../utils/auth')

Page({
  data: {
    mode: 'forgot', // 'forgot': 忘记密码, 'change': 修改密码
    currentStep: 1, // 1: 验证身份, 2: 重置密码
    form: {
      loginIdentifier: '',
      oldPassword: '', // 修改密码时需要原密码
      captcha: '',
      newPassword: '',
      confirmPassword: ''
    },
    // 全局加载状态
    globalLoading: false,
    globalLoadingText: '身份验证中...',
    showOldPassword: false,
    showPassword: false,
    showConfirmPassword: false,
    captchaCode: '',
    canVerify: false,
    canReset: false,
    loading: false,
    errorMsg: '',
    isAccountDisabled: false // 控制账户输入框是否禁用
  },

  // 显示全局加载
  showGlobalLoading(text = '身份验证中...') {
    const app = getApp()
    app.showGlobalLoading({
      loadingText: text
    })
  },

  // 隐藏全局加载
  hideGlobalLoading() {
    const app = getApp()
    app.hideGlobalLoading()
  },

  // 更新全局加载状态
  updateGlobalLoading(data) {
    this.setData({
      globalLoading: data.globalLoading,
      globalLoadingText: data.globalLoadingText || this.data.globalLoadingText
    })
  },

  onLoad(options) {
    // 显示页面加载效果
    this.showGlobalLoading('身份验证中...')
    console.log('忘记密码页面 onLoad 参数:', options)
    
    // 检查是否从其他页面传入模式参数
    const currentMode = options.mode || this.data.mode
    if (options.mode) {
      this.setData({ mode: options.mode })
    }
    
    // 根据模式动态设置页面标题
    const pageTitle = currentMode === 'change' ? '修改密码' : '忘记密码'
    wx.setNavigationBarTitle({
      title: pageTitle
    })
    
    // 检查来源页面参数
    const fromPage = options.from
    console.log('来源页面:', fromPage, '模式:', currentMode)
    
    // 如果是修改密码模式，获取当前用户信息
    if (this.data.mode === 'change') {
      const currentUser = authUtils.getCurrentUser()
      if (currentUser) {
        this.setData({
          'form.loginIdentifier': currentUser.accountNumber || currentUser.username || ''
        })
        
        // 如果来源是"我的"页面，禁用输入框
        if (fromPage === 'mine') {
          console.log('设置输入框为禁用状态')
          this.setData({
            isAccountDisabled: true
          })
        }
      }
    }
    
    // 如果是忘记密码模式且来源是"我的"页面，自动填充账号并禁用输入框
    if (this.data.mode === 'forgot' && fromPage === 'mine') {
      const currentUser = authUtils.getCurrentUser()
      if (currentUser && currentUser.accountNumber) {
        this.setData({
          'form.loginIdentifier': currentUser.accountNumber,
          isAccountDisabled: true
        })
      }
    }
    
    this.generateCaptcha()
    this.checkCanVerify()
    
    // 页面加载完成，隐藏加载状态
    setTimeout(() => {
      this.hideGlobalLoading()
    }, 500)
  },

  onShow() {
    this.setData({
      errorMsg: '',
      loading: false
    })
    this.checkCanVerify()
  },

  // 生成验证码
  generateCaptcha() {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
    let result = ''
    for (let i = 0; i < 4; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length))
    }
    this.setData({ captchaCode: result })
  },

  // 刷新验证码
  onRefreshCaptcha() {
    this.generateCaptcha()
    this.setData({ 'form.captcha': '' })
    this.checkCanVerify()
  },

  // 输入处理
  onLoginIdentifierInput(e) {
    // 如果输入框被禁用，不处理输入
    if (this.data.isAccountDisabled) {
      return
    }
    this.setData({ 'form.loginIdentifier': e.detail.value })
    this.checkCanVerify()
  },

  onOldPasswordInput(e) {
    this.setData({ 'form.oldPassword': e.detail.value })
    this.checkCanVerify()
  },

  onCaptchaInput(e) {
    this.setData({ 'form.captcha': e.detail.value.toUpperCase() })
    this.checkCanVerify()
  },

  onNewPasswordInput(e) {
    this.setData({ 'form.newPassword': e.detail.value })
    this.checkCanReset()
  },

  onConfirmPasswordInput(e) {
    this.setData({ 'form.confirmPassword': e.detail.value })
    this.checkCanReset()
  },

  // 切换密码显示
  onToggleOldPassword() {
    this.setData({ showOldPassword: !this.data.showOldPassword })
  },

  onTogglePassword() {
    this.setData({ showPassword: !this.data.showPassword })
  },

  onToggleConfirmPassword() {
    this.setData({ showConfirmPassword: !this.data.showConfirmPassword })
  },


  // 检查是否可以验证身份
  checkCanVerify() {
    const { loginIdentifier, oldPassword, captcha } = this.data.form
    
    if (this.data.mode === 'change') {
      // 修改密码模式：需要用户名和原密码
      const canVerify = loginIdentifier.trim().length >= 3 && oldPassword.length >= 6
      this.setData({ canVerify })
    } else {
      // 忘记密码模式：需要用户名和验证码
      const canVerify = loginIdentifier.trim().length >= 3 && captcha.length === 4
      this.setData({ canVerify })
    }
  },

  // 验证密码格式
  validatePassword(password) {
    if (!password) {
      return '请输入密码'
    }
    if (!/^[a-zA-Z][a-zA-Z0-9_@]{5,19}$/.test(password)) {
      return '密码必须以字母开头，长度6-20位，只能包含字母、数字、下划线、@'
    }
    return null
  },

  // 检查是否可以重置密码
  checkCanReset() {
    const { newPassword, confirmPassword } = this.data.form
    const passwordValid = /^[a-zA-Z][a-zA-Z0-9_@]{5,19}$/.test(newPassword)
    const canReset = passwordValid && confirmPassword === newPassword
    this.setData({ canReset })
  },

  // 验证身份
  async onVerifyIdentity() {
    if (!this.data.canVerify || this.data.loading) return

    const { loginIdentifier, oldPassword, captcha } = this.data.form

    this.setData({ loading: true, errorMsg: '' })

    try {
      if (this.data.mode === 'change') {
        // 修改密码模式：验证原密码
        // 直接使用登录接口验证原密码是否正确
        const currentUser = authUtils.getCurrentUser()
        const userRole = currentUser ? currentUser.role : 'citizen'
        
        const loginData = {
          loginIdentifier: loginIdentifier,
          password: oldPassword,
          role: userRole
        }

        try {
          await userApi.login(loginData)
          // 如果登录成功，说明原密码正确，进入下一步
          this.setData({ 
            currentStep: 2,
            loading: false,
            errorMsg: ''
          })
        } catch (error) {
          // 检查是否是密码错误
          if (error.message && (error.message.includes('登录标识或密码错误') || error.message.includes('密码错误'))) {
            wx.showModal({
              title: '验证失败',
              content: '原密码错误，请重新输入',
              showCancel: false,
              confirmText: '确定'
            })
            this.setData({ loading: false })
            return // 密码错误时不继续执行，避免跳转
          } else if (error.message && error.message.includes('用户不存在')) {
            wx.showModal({
              title: '验证失败',
              content: '用户名/账号/手机号不存在，请检查输入',
              showCancel: false,
              confirmText: '确定'
            })
            this.setData({ loading: false })
            return // 用户不存在时不继续执行，避免跳转
          } else {
            // 其他错误也说明用户存在，可以进入下一步
            this.setData({ 
              currentStep: 2,
              loading: false,
              errorMsg: ''
            })
          }
        }
      } else {
        // 忘记密码模式：先验证验证码
        if (captcha !== this.data.captchaCode) {
          wx.showModal({
            title: '验证失败',
            content: '验证码错误，请重新输入',
            showCancel: false,
            confirmText: '确定'
          })
          this.onRefreshCaptcha()
          this.setData({ loading: false })
          return
        }

        // 验证码正确后，校验用户是否存在
        try {
          const validateData = {
            loginIdentifier: loginIdentifier
          }
          
          const result = await userApi.validateUser(validateData)
          
          if (result.success && result.data.exists) {
            // 用户存在，进入下一步
            this.setData({ 
              currentStep: 2,
              loading: false,
              errorMsg: ''
            })
          } else {
            // 用户不存在
            wx.showModal({
              title: '验证失败',
              content: '验证的用户是不存在的，请检查输入',
              showCancel: false,
              confirmText: '确定'
            })
            this.setData({ loading: false })
          }
        } catch (error) {
          console.error('校验用户失败:', error)
          wx.showModal({
            title: '验证失败',
            content: error.message || '网络错误，请重试',
            showCancel: false,
            confirmText: '确定'
          })
          this.setData({ loading: false })
        }
      }

    } catch (error) {
      console.error('身份验证失败:', error)
      wx.showModal({
        title: '验证失败',
        content: '网络错误，请重试',
        showCancel: false,
        confirmText: '确定'
      })
      this.setData({ loading: false })
    }
  },

  // 重置密码
  async onResetPassword() {
    // 如果正在加载中，阻止重复点击
    if (this.data.loading) return

    const { loginIdentifier, oldPassword, newPassword, confirmPassword } = this.data.form

    this.setData({ loading: true, errorMsg: '' })

    // 验证密码格式
    const passwordError = this.validatePassword(newPassword)
    if (passwordError) {
      wx.showModal({
        title: '密码格式错误',
        content: passwordError,
        showCancel: false,
        confirmText: '确定'
      })
      this.setData({ loading: false })
      return
    }

    // 验证密码一致性
    if (newPassword !== confirmPassword) {
      wx.showModal({
        title: '密码不一致',
        content: '两次输入的密码不一致，请重新输入',
        showCancel: false,
        confirmText: '确定'
      })
      this.setData({ loading: false })
      return
    }

    try {
      const resetPasswordData = {
        loginIdentifier: loginIdentifier,
        newPassword: newPassword,
        confirmPassword: confirmPassword
      }

      // 如果是修改密码模式，添加原密码
      if (this.data.mode === 'change') {
        resetPasswordData.oldPassword = oldPassword
      }

      await userApi.resetPassword(resetPasswordData)

      // 密码修改成功提示并跳转登录页
      wx.showModal({
        title: '修改成功',
        content: '密码修改成功，请重新登录',
        showCancel: false,
        confirmText: '确定',
        success: () => {
          // 清空本地存储数据
          authUtils.clearCurrentUser()
          
          // 跳转到登录页面
          wx.redirectTo({ 
            url: '/pages/auth/login/index' 
          })
        }
      })

    } catch (error) {
      console.error('修改密码失败:', error)
      
      // 检查是否是密码验证失败的错误
      if (error.message && (error.message.includes('原密码错误') || error.message.includes('密码错误') || error.message.includes('登录标识或密码错误'))) {
        wx.showModal({
          title: '密码验证失败',
          content: '原密码错误，请重新输入',
          showCancel: false,
          confirmText: '确定'
        })
      } else {
        wx.showModal({
          title: '修改失败',
          content: error.message || '密码修改失败，请重试',
          showCancel: false,
          confirmText: '确定'
        })
      }
      
      this.setData({ loading: false })
    }
  },

  // 跳转到登录页
  onGoLogin() {
    wx.redirectTo({ url: '/pages/auth/login/index' })
  }
})
